Method, system and program product for selectively removing instrumentation logic from a simulation model

ABSTRACT

According to a method of simulation processing, a simulation model is received that includes a plurality of design entity instances modeling a digital system and one or more instrumentation entity instances, separate from the plurality of design entity instances, that generate instances of instrumentation events for testing purposes during simulation. In response to receiving an exclusion list identifying at least one instance of one or more instrumentation events to be removed from the simulation model, at least one instance of the one or more instrumentation events and associated logic elements are removed from the one or more instrumentation entity instances of the simulation model prior to simulation, such that a more compact simulation model is obtained.

CROSS-REFERENCE TO RELATED APPLICATION

The present invention is a continuation of U.S. patent application Ser.No. 11226,969, filed on Sep. 15, 2005, entitled “Method, System andProgram Product for Selectively Removing Instrumentation Logic from aSimulation Model” which is also related to the U.S. patent applicationSer. No. 10/970,468, which are incorporated herein by reference in theirentireties.

BACKGROUND OF THE INVENTION

1. Technical Field

The present invention relates in general to designing and simulatingdigital devices, modules and systems, and in particular, to a method andsystem for computer simulation of digital devices, modules and systemsutilizing a hardware description language (HDL) model. Moreparticularly, the present invention relates to methods, systems, andprogram products for selectively removing instrumentation logic from asimulation model.

2. Description of the Related Art

Verifying the logical correctness of a digital design and debugging thedesign, if necessary, are very important steps in most digital designprocesses. Logic networks are tested either by actually buildingnetworks or by simulating networks on a computer. As logic networksbecome highly complex, it becomes necessary to simulate a design beforethe design is actually built. This is especially true when the design isimplemented as an integrated circuit, since the fabrication ofintegrated circuits requires considerable time and correction ofmistakes is quite costly. The goal of digital design simulation is theverification of the logical correctness of the design.

In a typical automated design process that is supported by aconventional electronic computer-aided design (ECAD) system, a designerenters a high-level description utilizing a hardware descriptionlanguage (HDL), such as VHDL, producing a representation of the variouscircuit blocks and their interconnections. The ECAD system compiles thedesign description into a format that is best suited for simulation. Asimulator is then utilized to verify the logical correctness of thedesign prior to developing a circuit layout.

A simulator is typically a software tool that operates on a digitalrepresentation, or simulation model of a circuit, and a list of inputstimuli representing inputs of the digital system. A simulator generatesa numerical representation of the response of the circuit, which maythen either be viewed on the display screen as a list of values orfurther interpreted, often by a separate software program, and presentedon the display screen in graphical form. The simulator may be run eitheron a general-purpose computer or on another piece of electronicapparatus, typically attached to a general purpose computer, speciallydesigned for simulation. In either case, a translation from an HDLdescription to a simulation format, hereinafter referred to as asimulation executable model or simulation model, is required.

SUMMARY OF THE INVENTION

The present invention recognizes that simulation performance isgenerally enhanced if the simulation executable model is compact.Accordingly, in one embodiment of the present invention, a simulationmodel is received that includes a plurality of design entity instancesmodeling a digital system and one or more instrumentation entityinstances, separate from the plurality of design entity instances, thatgenerate instances of instrumentation events for testing purposes duringsimulation. In response to receiving an exclusion list identifying atleast one instance of one or more instrumentation events to be removedfrom the simulation model, at least one instance of the one or moreinstrumentation events and associated logic elements are removed fromthe one or more instrumentation entity instances of the simulation modelprior to simulation, such that a more compact simulation model isobtained.

All objects, features, and advantages of the present invention willbecome apparent in the following detailed written description.

BRIEF DESCRIPTION OF THE DRAWINGS

The novel features believed characteristic of the invention are setforth in the appended claims. The invention itself however, as well as apreferred mode of use, further objects and advantages thereof, will bestbe understood by reference to the following detailed description of anillustrative embodiment when read in conjunction with the accompanyingdrawings, wherein:

FIG. 1 depicts a exemplary data processing system that may be utilizedto practice the present invention;

FIG. 2A is a simplified block diagram illustrating a digital designentity that may be instrumented in accordance with the teachings of thepresent invention;

FIG. 2B is a diagrammatic representation depicting a simulation modelthat may be instrumented in accordance with the teachings of the presentinvention;

FIG. 2C is a flow diagram illustrating of a model build process that maybe implemented in accordance with the teachings of the presentinvention;

FIG. 2D is a block diagram depicting data structures that maybeinstrumented in accordance with the teachings of the present invention;

FIG. 3A is a simplified block diagram representative of aninstrumentation entity;

FIG. 3B is a simplified block diagram of a simulation model instrumentedin accordance with the teachings of the present invention;

FIG. 3C illustrates exemplary sections of HDL syntax that maybe utilizedin accordance with the teachings of the present invention;

FIG. 3D is a flow diagram depicting a model build process in accordancewith the teachings of the present invention;

FIG. 3E is a block diagram representation of memory data structuresconstructed in accordance with the teachings of the present invention;

FIG. 4 is a logic diagram representation of a runtime disable mechanismin accordance with the teachings of the present invention;

FIG. 5 is a simplified gate level representation of an exemplarycounting instrument with a runtime disable feature and automaticclocking adjustment in accordance with the teachings of the presentinvention;

FIG. 6A is a block diagram illustrating a simulation model containing anumber of design and instrumentation entities;

FIG. 6B depicts a data structure for declaring an event within asimulation model in accordance with one embodiment of the presentinvention;

FIG. 6C illustrates a list of extended event data structures for thesimulation model in FIG. 6A;

FIG. 6D depicts a data structure for declaring an event within asimulation model in accordance with an alternate embodiment of thepresent invention;

FIG. 7A is a block diagram illustrating a simulation model in which thehierarchical event processing of the present invention is applicable;

FIG. 7B depicts a set of input port mapping comments for performinghierarchical processing of simulation model events in accordance with afirst embodiment of the present invention;

FIG. 7C illustrates a set of input port mapping comments for performinghierarchical processing of simulation model events in accordance with asecond embodiment of the present invention;

FIG. 8A depicts a representative target design entity with aninstrumentation entity containing random instrumentation logicimplemented in accordance with the teachings of the present invention;

FIG. 8B illustrates an exemplary HDL file for implementinginstrumentation logic within an HDL design entity in accordance with theteachings of the present invention;

FIG. 9A depicts an exemplary embodiment of an exclusion file inaccordance with the present invention;

FIG. 9B is a block diagram of an exemplary instrumentation entityinstance from which an instrumentation event and associated logicelements may be removed in accordance with the present invention;

FIG. 9C is a high level logical flowchart of a first exemplary method ofselectively removing instrumentation event instances and associatedlogic elements from a simulation model in accordance with the presentinvention;

FIGS. 10A-10D together form a high level logical flowchart of a secondexemplary method of selectively removing instrumentation event instancesand associated logic elements from a simulation model in whichinstrumentation events may depend upon other instrumentation events inaccordance with the present invention; and

FIGS. 11A-11D depict the selective removal of instrumentation eventinstances and associated logic from a simulation model in accordancewith the present invention.

DETAILED DESCRIPTION OF A PREFERRED EMBODIMENT

The present invention provides for accurate and comprehensive monitoringof a digital circuit design in which a designer creates instrumentationmodules, for example, utilizing the same hardware description language(HDL) as utilized for the design itself. HDLs, while suited to the needsof digital designers, can also be effectively utilized for a number ofchecking functions. In accordance with the present invention,instrumentation modules are utilized to monitor specified designparameters while not becoming compiled as an integral part of the designitself. Furthermore, since the instrumentation modules are written inthe same HDL as utilized in the actual design, such modules are platformand simulator independent. Unlike checking done with C or C++ programs,HDL instrumentation can be compiled and run directly without loss ofperformance on hardware simulators.

With reference now to the figures, and in particular with reference toFIG. 1, there is depicted a pictorial representation of a dataprocessing system 10 with which the present invention may beadvantageously utilized. As illustrated, data processing system 10includes one or more Central Processing Units (CPUs) 24, such as aconventional microprocessor, and a number of other componentsinterconnected via a system interconnect 26. CPU(s) 24 execute orinterpret the instructions comprising computer programs, in part byperforming the arithmetical and logical functions indicated by suchinstructions. Although not depicted in FIG. 1, CPUs such as CPU 24typically include a control unit that organizes data and program storagein a computer memory and transfers the data and other informationbetween the various parts of the computer system. Such CPUs alsogenerally include one or more execution units that execute instructionsto perform arithmetical and logical operations, such as addition,comparison, multiplication and so forth.

Data processing system 10 further includes random-access memory (RAM)28, read-only memory (ROM) 30, a display adapter 32 for connectingsystem interconnect 26 to display device 14, and an I/O adapter 34 forconnecting peripheral devices (e.g., optical, disk and tape drives 33)to system interconnect 26.

Data processing system 10 further includes user interface adapter 36 forconnecting keyboard 16, mouse 20, speaker 38, microphone 40, and/orother user interface devices to system interconnect 26. Communicationsadapter 42 further connects data processing system 10 to one or moreother computers and/or a communication network.

The nonvolatile and/or volatile internal storage of data processingsystem 10 (e.g., main memory 44, ROM 30, RAM 28 and/or disk/tape drive33) stores software including a conventional operating system andadditional middleware and/or application software. Such additionalsoftware includes an ECAD tool 12 that is processed by CPU(s) 24 topermit the development and verification of a digital circuit design inaccordance with the present invention. ECAD tool 12 preferably presentsa graphical user interface (GUI) via display device 14 with which adigital circuit designer can interact using a keyboard 16 and mouse 20.Thus, by entering appropriate inputs utilizing keyboard 16 and mouse 20,the digital circuit designer is able to develop and verify a digitalcircuit design according to the method described further hereinbelow.The additional software further includes a control program 46 (shownwithin main memory 44) that, when processed by CPU 24, carries out theoperations depicted in FIG. 2C and FIG. 3D and described below.

Simulated digital circuit design models are comprised of at least oneand usually many sub-units referred to hereinafter as design entities.FIG. 2A is a block diagram representation of an exemplary design entity300. Design entity 300 is defined by a number of components: an entityname, entity ports, and are presentation of the function performed bydesign entity 300. Each entity within a given model has a unique name(not explicitly shown in FIG. 2A) that is declared in the HDLdescription of each entity. Furthermore, each entity typically containsa number of signal interconnections, known as ports, to signals outsidethe entity. These outside signals may be primary input/outputs (I/Os) ofan overall design or signals connecting to other entities within anoverall design.

Typically, ports are categorized as belonging to one of three distincttypes: input ports, output ports, and bi-directional ports. Designentity 300 is depicted in as having a number of input ports 303 thatconvey signals into design entity 300. Input ports 303 are connected toinput signals 301. In addition, design entity 300 includes a number ofoutput ports 306 that convey signals out of design entity 300. Outputports 306 are connected to a set of output signals 304. Bi-directionalports 305 are utilized to convey signals into and out of design entity300. Bi-directional ports 305 are in turn connected to a set ofbi-directional signals 309. An entity, such as design entity 300, neednot contain ports of all three types, and in the degenerate case,contains no ports at all. To accomplish the connection of entity portsto external signals, a mapping technique, known as a “port map”, isutilized. A port map (not explicitly depicted in FIG. 2A) indicates aspecified correspondence between entity port names and external signalsto which the entity is connected. When building a simulation model, ECADtool 12 is utilized to connect external signals to appropriate ports ofthe entity according to a port map specification.

Finally, design entity 300 contains a body section 308 that describesone or more functions performed by design entity 300. In the case of adigital design, body section 308 contains an interconnection of logicgates, storage elements, etc., in addition to instantiations of otherentities. By instantiating an entity within another entity, ahierarchical description of an overall design is achieved. For example,a microprocessor may contain multiple instances of an identicalfunctional unit. As such, the microprocessor itself will often bemodeled as a single entity. Within the microprocessor entity, multipleinstantiations of any duplicated functional entities will be present.

Referring now to FIG. 2B, there is illustrated a diagrammaticrepresentation of an exemplary simulation model 329 that may be utilizedin a preferred embodiment of the present invention. Simulation model 329includes of multiple hierarchical entities. For visual simplicity andclarity, the ports and signals interconnecting the entities withinsimulation model 329 have not been explicitly shown. In any model, oneand only one entity is the so-called “top-level entity”. A top-levelentity 320 is that entity which encompasses all other entities withinsimulation model 329. That is to say, top-level entity 320 instantiates,either directly or indirectly, all descendant entities within a design.Simulation model 329 includes of top-level entity 320 which directlyinstantiates two instances, 321 a and 321 b , of an FXU entity 321 and asingle instance of an FPU entity 322. Each instantiation has anassociated description, which contains an entity name and a uniqueinstantiation name. For top-level entity 320, description 310 is labeled“TOP:TOP”. Description 310 includes an entity name 312, labeled as the“TOP” preceding the colon, and also includes an instantiation name 314,labeled as the “TOP” following the colon.

It is possible for a particular entity to be instantiated multiple timesas is depicted with instantiations 321 a and 321 b of FXU entity 321.Instantiations 321 a and 321 b are distinct instantiations of FXU entity321 with instantiation names FXU0 and FXU1 respectively. Top-levelentity 320 is at the highest level within the hierarchy of simulationmodel 329. An entity that instantiates a descendant entity will bereferred to hereinafter as an “ancestor” of the descendant entity.Top-level entity 320 is therefore the ancestor that directlyinstantiates FXU entity instantiations 321 a and 321 b. At any givenlevel of a simulation model hierarchy, the instantiation names of allinstantiations must be unique.

In addition to FXU entity instantiations 321 a and 321 b, top-levelentity 320 directly instantiates a single instance of a FPU entity 322having an entity name FPU and instantiation name FPU0. Within an entitydescription, it is common for the entity name to match the instantiationname when only one instance of that particular entity is placed at agiven level of a simulation model hierarchy. However, this is notrequired as shown by entity 322 (instantiation name FPU0, entity nameFPU).

Within instantiation 321 a of FXU entity 321, single instance entities325 a and 326 a of entity A 325 and entity B 326 respectively, aredirectly instantiated. Similarly, instantiation 321 b of the same FXUentity contains instantiations 325 b and 326 b of entity A 325 andentity B 326 respectively. In a similar manner, instantiation 326 a andinstantiation 326 b each directly instantiate a single instance ofentity C 327 as entities 327 a and 327 b respectively. The nesting ofentities within other entities can continue to an arbitrary level ofcomplexity provided that all entities instantiated, whether singly ormultiply, have unique entity names and the instantiation names at anygiven level of the hierarchy are unique with respect to one another.Each entity is constructed from one or more HDL files that contain theinformation necessary to describe the entity.

Associated with each entity instantiation is a so called “instantiationidentifier”. The instantiation identifier for a given instantiation is astring built from the enclosing entity instantiation names proceedingfrom the top-level entity instantiation name. For example, theinstantiation identifier of instantiation 327 a of entity C 327 withininstantiation 321 a of FXU entity 321 is “TOP.FXU0.B.C”. This identifierserves to uniquely identify each instantiation within a simulationmodel.

Referring now to FIG. 2C, there is depicted a flow diagram of a modelbuild process which maybe implemented in a preferred embodiment of thepresent invention. The process begins with one or more design entity HDLsource code files 340. HDL compiler 342 processes HDL file(s) 340beginning with the top level entity of a simulation model and proceedingin a recursive fashion through all HDL file(s) describing a completesimulation model.

HDL compiler 342 also creates two sets of data structures, design entityproto data structures 341 and design entity instance data structures343, in memory 44 of computer system 10. Design entity proto datastructures 341 and design entity instance data structures 343, serve asa memory image of the contents of a simulation executable model 348.Data structures 341 and 343 are passed, via memory 44, to a model buildtool 346 that processes data structures 341 and 343 into simulationexecutable model 348.

It will be assumed hereinafter that each entity is described by a singleHDL file. Depending on convention or the particular HDL in which thecurrent invention is practiced, this restriction may be required.However, in certain circumstances or for certain HDLs it is possible todescribe an entity by utilizing more than one HDL file. Those skilled inthe art will appreciate and understand the extensions necessary topractice the present invention if entities are permitted to be describedby multiple HDL files. Furthermore, it will be assumed that there is adirect correspondence, for each entity, between the entity name and bothof the following: the name of the HDL file representing the entity, andthe name of the proto file for the entity.

In the following description, an HDL source code file corresponding to agiven entity will be referred to by an entity name followed by “.vhdl”.For example, the HDL source code file that describes top-level entity320 will be referred to as TOP.vhdl. This labeling convention serves asa notational convenience only and should not be construed as limitingthe applicability of the present invention to HDLs other than VHDL.

Returning to FIG. 2B, it can be seen that each entity may instantiate,either directly or indirectly, one or more other entities. For example,the FXU entity directly instantiates A entity 325 and B entity 326.Furthermore, B entity 326 directly instantiates C entity 327. Therefore,FXU entity 321 instantiates, directly or indirectly, A entity 325, Bentity 326 and C entity 327. Those entities, that are directly orindirectly instantiated by another entity, will be referred tohereinafter as “descendants”. The descendants of top level entity 320are FXU entity 321, FPU entity 322, A entity 325, B entity 326, and Centity 327. It can be seen that each entity has a unique set ofdescendants and that each time an entity is instantiated, a uniqueinstance of the entity and its descendants is created. Within simulationmodel 329, FXU entity 321 is instantiated twice, FXU:FXU0 321 a andFXU:FXU1 321 b , by top-level entity 320. Each instantiation of FXUentity 321 creates a unique set of instances of the FXU, A, B, and Centities.

Returning to FIG. 2C, HDL compiler 342 creates an image of the structureof a simulation model in main memory 44 of computer system 10. Thismemory image is comprised of the following components: “proto” datastructures 341 and “instance” data structures 343. A proto is a datastructure that, for each entity in the model, contains information aboutthe ports of the entity, the body contents of the entity, and a list ofreferences to other entities directly instantiated by the entity (inwhat follows, the term “proto” will be utilized to refer to thein-memory data structure described above).

An instance data structure is a data structure that, for each instanceof an entity within a model, contains the instance name for theinstance, the name of the entity the instance refers to, and the portmap information necessary to interconnect the entity with externalsignals. During compilation, each entity will have only one proto datastructure, while, in the case of multiple instantiations of an entity,each entity may have one or more instance data structures.

With reference now to FIG. 2D there is depicted a block diagramrepresenting compiled data structures, which may be implemented in apreferred embodiment of the present invention. Memory 44 contains protodata structures 361, one for each of the entities referred to insimulation model 329. In addition, instantiations in simulation model329 are represented by instance data structures 362. Instance datastructures 362 are connected by means of pointers indicating thehierarchical nature of the instantiations of the entities withinsimulation model 329. Model build tool 346 in FIG. 2C processes thecontents of memory 44 into memory data structures in order to producesimulation executable model 348.

In order to instrument simulation models, the present invention makesuse of entities known as “instrumentation entities,” which are incontrast to the entities constituting a design which are referred toherein as “design entities”. As with design entities, instrumentationentities are described by one or more HDL source code files and includea number of signal ports, a body section, and an entity name. In whatfollows, it will be assumed that an instrumentation entity is describedby a single HDL file. Those skilled in the art will appreciate andunderstand extensions necessary to practice the current invention for aninstrumentation entity that is described by multiple HDL files. Eachinstrumentation entity is associated with a specific design entityreferred to hereinafter as the “target entity”.

With reference now to FIG. 3A, there is illustrated a block diagramrepresentation of an instrumentation entity 409. Instrumentation entity409 includes a number of input ports 400 that are connected to signals401 within a target entity (not depicted in FIG. 3A). A body section 402contains logic necessary to detect occurrences of specified conditionswithin the target entity and generate simulation model “events” withrespect to signals 401. Three distinct types of events may be generated:“count” events, “fail” events, and “harvest” events, each describedbelow in turn. Body section 402 contains internal logic for detectingoccurrences of conditions precipitating generation of these events. Aset of multi-bit output ports 403, 404, and 405 are connected toexternal instrumentation logic (depicted in FIG. 3B) by means ofexternal signals 406, 407, and 408. Output ports 403, 404, and 405 thusprovide the connection from the internal logic in body section 402 tothe external instrumentation logic which is utilized to indicate theoccurrence of count, failure and harvest events.

A failure event is a sequence of signal values that indicate a failurein the correct operation of the simulation model. Each instrumentationentity monitors the target entity for any desired number of failureevents. Each occurrence of a failure event is assigned to a particularsignal bit on output port 403. Logic within body section 402 produces anactive high pulse on a specified bit of signal 403 when a failurecondition is detected. Such activation of signal 403 is defined as afailure event. This error indication is conveyed by means of externalsignal 406 to external instrumentation logic (depicted in FIG. 3B asexternal instrumentation logic block 420), which flags the occurrence ofthe failure event.

A count event is a sequence of signal values that indicate theoccurrence of an event within a simulation model for which it would beadvantageous to maintain a count. Count events are utilized to monitorthe frequency of occurrence of specific sequences within a simulationmodel. Each instrumentation entity can monitor the target entity for anydesired number of count events. Each count event is assigned to aparticular signal bit on output port 405. Logic block 402 contains thelogic necessary to detect the occurrence of the desired count events andproduces an active high pulse on the specified bit of signal 405 when acount event is detected. This count indication is conveyed by means ofexternal signal 408 to instrumentation logic, which contains countersutilized to record the number of occurrences of each count event.

The third event type, a harvest event, is a sequence of signal valuesthat indicate the occurrence of a specific operative circumstance, whichwould be advantageous to be able to reproduce. When a harvest eventoccurs, a register within an external instrumentation logic block isloaded to indicate at what point within a simulation run the eventoccurred, and a flag is set to indicate the occurrence of the specificcircumstance. The details of the simulation run can thus be saved inorder to recreate the specific circumstance monitored by the harvestevent. Logic block 402 contains the logic necessary to detect theharvest events.

Each instrumentation entity can detect any desired number of harvestevents that are each assigned to a particular signal bit on output port404. Logic within block 402 produces an active high pulse on thespecified bit of signal 404 when a harvest event is detected. Thisharvest event detection is conveyed by means of external signal 407 toexternal instrumentation logic that contains a register and flag foreach harvest event. The register is utilized to record at which point inthe simulation run the harvest event occurred, and the flag is utilizedto indicate the occurrence.

With reference now to FIG. 3B, there is depicted a block diagramrepresentation of simulation model 329 instrumented in accordance withthe teachings of the present invention. As can be seen in FIG. 3B, aninstance 410 and an instance 411 of an instrumentation entity FXUCHK areutilized to monitor instances 321 a and 321 b of an FXU entity. For eachFXU instantiations of 321 a and 321 b, an FXUCHK instantiation, 410 and411 respectively, is automatically generated by the mechanism of thepresent invention. In a similar fashion, instrumentation entity FPUCHK412 is instantiated to monitor FPU entity 322.

As depicted in FIG. 3B, entity FXUCHK monitors a signals Q 372, a signalR 376, and a signal S 374 within each of instances 321 a and 321 b ofthe FXU entity. Signal Q 372, is a signal within the instances 325 a and325 b of descendant entity A. Likewise, signal S 374 is a signal withindescendant entity C that resides within descendant entity B. Finally,signal R 376 occurs directly within FXU entity 321. Although aninstrumentation entity may monitor any signal within a target entity orthe target entity's descendent entities, signals outside the targetentity cannot be monitored.

Each instrumentation entity is connected by means of fail, count, andharvest signals to instrumentation logic block 420 containing logic forrecording occurrences of each of the three event types. For the countevents monitored in simulation model 329, a set of counters 421 isutilized to count the number of occurrences of each count event. In asimilar manner, a set of flags 424 is utilized to record the occurrenceof failure events. Finally, a set of counters 422 and flags 423 arecombined and utilized to record the point at which a harvest eventoccurs and its occurrence, respectively. In one embodiment of thepresent invention, a cycle number is captured and stored utilizingcounters 422 and flags 423 to record a harvest event.

To facilitate instantiation and connection of instrumentation entities,instrumentation entity HDL source code files include a specializedcomment section, hereinafter referred to as “instrumentation entitydescription”, that indicates the target entity, the signals within thetarget entity to be monitored, and information specifying types ofevents to be monitored.

With reference now to FIG. 3C, there is illustrated an exemplary HDLfile 440 that describes instrumentation entity FXUCHK depicted in FIG.3B. HDL file 440 utilizes the syntax of the VHDL hardware descriptionlanguage. In the VHDL language, lines beginning with two dashes (“--”)are recognized by a compiler as being comments. The method and system ofthe present invention utilize comments of a non-conventional form toindicate information about an instrumentation entity. FIG. 3C depictsone embodiment of the present invention in which comments begin with twoexclamation points in order to distinguish these comments fromconventional comments in instrumentation HDL file 440. It will beappreciated by those skilled in the art that the exemplary syntaxutilized in FIG. 3C for the provision of unconventional comments is butone of many possible formats.

Within HDL file 440, the I/O ports of a FXUCHK entity are declared inentity declaration 450. Within entity declaration 450, three inputports, S_IN, Q_IN, and R_IN, respectively, are declared. Input ports,S_IN, Q_IN, and R_IN, will be attached to signal S, 374, signal Q, 372,and signal R, 376 respectively as described below. Input port, CLOCK, isalso declared and will be connected to a signal, CLOCK, within the FXUentity. In addition, three output ports: fails (0 to 1), counts(0 to 2),and harvests(0 to 1), are declared. These output ports provide failure,count, and harvest signals for two failure events, three count events,and two harvest events. The names of the output ports are fixed byconvention in order to provide an efficient means for automaticallyconnecting these signals to instrumentation logic block 420.

A set of instrumentation entity descriptors 451 is utilized to provideinformation about the instrumentation entity. As illustrated in FIG. 3C,descriptor comments 451 may be categorized in a number of distinctsections: prologue and entity name declaration 452, an input port map453, a set of failure message declarations 454, a set of counterdeclarations 455, a set of harvest declarations 456, and an epilogue457.

The prologue and entity name 452 serve to indicate the name of theparticular target entity that the instrumentation entity will monitor.Prologue and entity name declaration 452 also serves as an indicationthat the instrumentation entity description has begun. Specifically, thecomment “--!! Begin” within prologue and entity name 452, indicates thatthe description of an instrumentation entity has begun. The comment“--!! Design Entity: FXU” identifies the target entity which, in HDLfile 440, is design entity FXU. This declaration serves to bind theinstrumentation entity to the target entity.

Input port map 453 serves as a connection between the input ports of aninstrumentation entity and the signals to be monitored within the targetentity. The comments begin with comment “--!! Inputs” and end withcomment “--!! End Inputs”. Between these comments, comments of the form“--!! inst_ent_port_name=>trgt_ent_signal_name” are utilized, one foreach input port of the instrumentation entity, to indicate connectionsbetween the instrumentation entity ports and the target entity signals.The inst_ent_port_name is the name of the instrumentation entity port tobe connected to the target entity signal. The trgt_ent_signal_name isthe name of the signal within the target entity that will be connectedto the instrumentation entity port.

In some cases a signal to be monitored lies within a descendant of atarget entity. This is the case for signal S 374, which is embeddedwithin entity C which is a descendant of entity B 326 and target FXUentity 321. Input port map 453 includes an identification string forsignal S 374, which includes the instance names of the entities withinthe target entity each separated by periods (“.”). This identificationstring is pre-pended to the signal name. The signal mapping commentwithin input port map 453 for signal S 374 is therefore as follows:

-   -   --!! S_IN=>B.C.S;

This syntax allows an instrumentation entity to connect to any signalwithin the target entity or the target entity's descendant entities. Asignal appearing on the top level of the target design entity, has nopre-pended entity names; and therefore, has the following signal mappingcomment:

-   -   --!! R_IN=>R;

For signals on the top level of the target entity, a special connectionmethod is provided. If the signal to be connected to has the same nameas its corresponding signal in the port map of the instrumentationentity, no input port mapping comment is required and the signal will beautomatically connected if no such comment is present. In other words,if the input port mapping comment is of the form:

-   -   --!! signal=>signal;        where signal is a legal signal name without periods (“.”), then        the input port mapping comment is not required and the system of        the present invention will automatically make the connect. It is        also possible to provide comments of the form given above to        explicitly denote the signal connection. This mechanism is only        operative for signals on the top level of the target entity.

Failure message declarations 454 begin with a comment of the form “--!!Fail Outputs;”, and end with a comment of the form “--!! End FailOutputs;”. Each failure event output is associated with a unique eventname and a failure message. This message may be output by the simulationrun-time environment upon detecting a failure event. The unique failureevent name is utilized to identify the specific failure event within themodel. Each failure event signal may be declared by a comment of theform “--!! n: <eventname> “failure message”;” where n is an integerdenoting the failure event to which the message is associated,<eventname> is the unique failure event name, and “failure message” isthe message associated with the particular failure event. One and onlyone failure message declaration comment must be provided for eachfailure event monitored by the instrumentation entity.

Counter declaration comments 455 begin with a comment of the form “--!!Count Outputs;” and end with a comment of the form “--!! End CountOutputs;”. Each count event output is associated with a unique variablename. This name is associated with a counter in counter logic 421 FIG.3B. The variable name provides a means to identify and reference theparticular counter associated with a particular count event. Thus, acomment of the form “--!! n : <varname> qualifying_signal [±];” isassociated with each counter event output. Within this convention, n isan integer denoting which counter event in the instrumentation module isto be associated with a variable name “varname,” and qualifying_signalis the name of a signal within a target design entity utilized todetermine when to sample the count event pulse, as will be furtherdescribed hereinbelow. The parameter “qualifying_signal” is followed byA±A to specify whether the qualifying signal will be a high activequalifying signal or a low active qualifying signal.

Harvest declarations 456 begin with a prologue comment of the form “--!!Harvest Outputs;” and end with a comment of the form “--!! End HarvestOutputs;”. Each harvest event output is associated with a unique eventname and a message that maybe output by the simulation runtimeenvironment when a harvest event has occurred during a simulation run.Each harvest event signal is declared in the form “--!! n: <eventname>“harvest message”;” where n is an integer denoting which harvest eventthe message is to be associated with, <eventname> is the unique harvestevent name and “harvest message” is the message to be associated withthe particular harvest event. One, and only one, harvest messagedeclaration comment must be provided for each harvest event monitored bythe instrumentation entity.

Harvest messages and event names, fail messages and event names, andcounter variable names for a simulation model are included in asimulation executable model and lists of all the events within the modelare produced in separate files at model build time. In this manner, eachsimulation model includes the information for each event monitored and aseparate file containing this information for each event is available.Furthermore, as will be described below, the model build process nameseach event within the model (count, fail and harvest) model in such amanner as to insure that each event has a unique name with certainuseful properties.

Finally, epilogue comment 457 includes a single comment of the form“--!! End;”, indicating the end of descriptor comments 451. Theremainder of instrumentation entity HDL file 440 that follows the I/Odeclarations described above is an entity body section 458. In entitybody section 458, conventional HDL syntax is utilized to define internalinstrumentation logic necessary to detect the various events on theinput port signals and convey these events to the output port signals.

In addition to descriptor comments 451, that are located in the HDLsource code file for an instrumentation entity, an additional commentline is required in the target entity HDL file. A comment of the form“--!! Instrumentation: name.vhdl”, where name.vhdl is the name of theinstrumentation entity HDL file, is added to the target entity HDLsource code file. This comment provides a linkage between theinstrumentation entity and its target entity. It is possible to havemore than one such comment in a target entity when more than oneinstrumentation entity is associated with the target entity. These HDLfile comments will hereinafter be referred to as “instrumentation entityinstantiations”.

With reference now to FIG. 3D, there is depicted an exemplary modelbuild process in accordance with the teachings of the present invention.In this model build process, instrumentation load tool 464 is utilizedto alter the in-memory proto and instance data structures of asimulation model thereby adding instrumentation entities to thesimulation model. Instrumentation load tool 464 utilizes descriptorcomments 451 within instrumentation HDL files 461 to create instancedata structures for the instrumentation entities within a simulationmodel.

The model build process of FIG. 3D begins with design entity HDL files340 and instrumentation entity HDL files 460. HDL compiler 462 compilesdesign entity HDL files 340 and instrumentation entity HDL files 461 inorder to produce in-memory design proto data structures 463 and designinstance data structures 465 for the design entities of a simulationmodel. HDL compiler 462 also creates in-memory instrumentation protodata structures 466 for the instrumentation entities of a simulationmodel.

In order to minimize processing overhead HDL compiler 462 neither readsnor processes descriptor comments 451. However, HDL compiler 462 doesrecognize instrumentation entity instantiation comments within targetentity HDL files. As such, HDL compiler 462 cannot create instance datastructures instrumentation entity data structures 467. The creation ofinstance data structures requires interconnection information containedwithin descriptor comments 451 not processed by HDL compiler 462. HDLcompiler,462 does, however, create instrumentation proto data structures466.

The in-memory design proto data structures 463, design instance datastructures 465, and instrumentation entity proto data structures 466 areprocessed by instrumentation load tool 464. Instrumentation load tool464 examines design entity proto data structures 463 and design entityinstance data structures 465 to determine those design entities that aretarget entities. This examination is accomplished by utilizing aparticular comment format as previously described.

For each target entity loaded from design entity HDL files 340,instrumentation load tool 464 must alter its design proto data structure463 and its design instance data structure 465 to instantiate anassociated instrumentation entity. An instrumented design proto datastructure 463 a and instrumented design instance data structure 465 aare thereby produced. In addition, instrumentation load tool 464 createsan instrumentation instance data structure 467 for each instrumentationentity associated with the current design entity.

Finally, instrumentation load tool 464 creates a unique proto andinstance data structure for instrumentation logic block 420 and connectsthe fail, harvest, and count event signals from each instrumentationentity instantiation to instrumentation logic block 420. In-memory protoand instance data structures 463 a, 465 a, 467, 466, instrumentationlogic block 420, and optionally an exclusion list (which may becontained in an exclusion file 443) are received and processed by amodel preprocessor 445.

In an exemplary embodiment, model preprocessor 445 performs at least twofunctions. First, model preprocessor 445 “flattens” the simulationmodel. As depicted in FIG. 3E, in-memory proto and instance datastructures 463 a, 465 a, 467, 466 describe the simulation model in an“unflattened” representation. The unflattened representation of thesimulation model includes a set of proto data structures 481 containinga single proto for each respective instrumentation or design entitybelonging to the simulation model. Each such proto serves as a templatefor all the instances of that entity within the simulation model. Theunflattened representation further includes an instance data structure482 containing pointers and references to those entities that describethe overall structure of the simulation model. For example, FIG. 3Edepicts an exemplary instance data structure 482 indicating aninstantiation of instrumentation entity FXUCHK in each of the twoinstances of design entity FXU and an instantiation of instrumentationentity FPUCHK within the single instance of design entity FPU. Instancedata structure 482 thus indicates the hierarchical nature of theinstantiations of the design and instrumentation entities within thesimulation model utilizing pointers and references to proto datastructures 481.

Model preprocessor 445 “flattens” the simulation model by creating a“sea of gates” representation of the simulation model containingexplicit copies of all the gates and other logic elements of eachinstance of each entity within the simulation model. Thus, the flattenedrepresentation of the simulation model contains, in addition to or inlieu of instance data structure 482, explicit copies of all the logicelements of the design and instrumentation entities rather than merelypointers to proto data structures 481.

Second, as described in greater detail below, the flattening of thesimulation model by model preprocessor 445 facilitates the selectiveremoval of individual instances of a given instrumentation event fromsome or all instrumentation entity instances instantiating the event. Inone preferred embodiment, the event instances to be removed areindicated by an exclusion list contained in one or more exclusion files443, which are described in detail below with reference to FIG. 9A.

The flattened simulation model produced by model preprocessor 445 ispassed to model build tool 446, which produces an instrumentedsimulation executable model 480.

With reference now to FIG. 4, failure flags 424 of instrumentation logicblock 420 are depicted in greater detail. Failure flags 424 areregisters 500 a-500 n utilized to accept and store an indication of theoccurrence of a failure event. In what follows, the operation of asingle failure flag for a particular failure event 502 will bediscussed. The operation of all failure flags is similar.

Register 500 a holds a value that represents whether a failure event 502has occurred or not. Register 500 a is initially set to a value of ‘0’by the simulation run-time environment at the beginning of a simulationrun. When failure event 502, if enabled at register 507 a, occurs,register 500 a is set to a value of a logical ‘1’, thereby indicatingthe occurrence of a failure event. Register 500 a is driven by logicalOR gate 501. Logical OR gate 501 performs a logical OR of the output ofregister 500 a and a qualified failure signal 503 to create the nextcycle value for register 500 a. In this manner, once register 500 a isset to a logical ‘1’ by the occurrence of an enabled failure event,register 500 a maintains the value of a logical ‘1’ until reset by thesimulation runtime environment. Likewise, register 500 a maintains avalue of ‘0’ from the beginning of the simulation run until theoccurrence of the failure event, if enabled.

Qualified failure signal 503 is driven by logical AND gate 505. LogicalAND gate 505 produces, on qualified failure signal 503, the logical ANDof failure signal 506 and the logical NOT of register 507 a. Register507 a serves as an enabling control for qualified failure signal 503. Ifregister 507 a contains a value of ‘0’, logical AND gate 505 will passfailure event signal 506 unaltered to qualified failure signal 503. Inthis manner, the monitoring of the failure event is enabled. Registers507 a-507 n are set, by default, to a value of ‘0’. However, if register507 a contains a value of a ‘1’, qualified failure signal 503 willremain at a value of ‘0’ irrespective of the value of failure eventsignal 506, thereby disabling the monitoring of failure event 502. Inthis manner, register 508, which includes registers 507 a-507 n, canmask the occurrence of any subset of failure events in the overallsimulation model from registers 500 a-500 n.

To efficiently implement the ability to selectively disable themonitoring of failure events, the simulation run-time environmentincludes a function that allows a user to disable monitoring of aspecific failure event for a given instrumentation entity. This functionwill automatically set the appropriate registers among registers 507a-507 n within register 508 to disable the monitoring of a particularfailure event for every instance of the instrumentation entity withinthe overall simulation model. Instrumentation load tool 464 and modelbuild tool 446 encode sufficient information within instrumentedsimulation executable model 480 to determine which failure bits withinregister 508 correspond to which instrumentation entities.

The ability to selectively disable monitoring of failure events is ofparticular use in large batch-simulation environments. Typically, insuch an environment, a large number of general purpose computers,running software or hardware simulators, are dedicated to automaticallyrunning a large number of simulation runs. If a simulation model with afaulty instrumentation entity that incorrectly indicates failure eventsis run in such an environment, a large number of erroneous failures willbe generated causing lost time. By selectively disabling failure eventswithin instrumentation entities, the present invention allows simulationto continue while only disabling erroneous failure signals rather thanhaving to disable all failure monitoring. This option is particularlyuseful when the process of correcting a faulty instrumentation entityand creating a new simulation model is substantially time consuming. Thepresent invention also provides similar enabling and disablingstructures for the harvest and count events within a model.

With reference now to FIG. 5, there is depicted a gate levelrepresentation of exemplary logic for one counter of counters 421 withininstrumentation logic block 420 depicted in FIG. 3B. Each counter of 421is represented by a multi-bit simulator latch 600. Simulator latch 600is initialized by the simulation runtime environment to a value of zeroat the beginning of a simulation run. Simulator latch 600 is updatedevery simulator cycle and is driven by multiplexer 601. Multiplexer 601,controlled by selector signal 602, selects between signal 613, thecurrent value of simulator latch 600, and signal 605, the current valueof simulator latch 600 incremented by 1 by incrementer 604, to serve asthe next cycle value for simulator latch 600. By selecting signal 605,multiplexer 601 causes the counter value within simulator latch 600 tobe incremented when a count event occurs. It should be noted, however,that simulator latch 600 is updated every simulator cycle irrespectiveof the number of simulator cycles that correspond to a design cycle forthe logic being monitored by a counting instrument. Logical AND gate 606and simulator latch 607 serve to disable the monitoring of count eventsignal 609 in a manner similar to that described above for the disablingof failure events. Signal 608 is count event signal 609 furtherqualified by signal 610 by means of logical AND gate 611.

Signal 610 insures that simulator latch 600 will be incremented, ifcount event signal 609 is active, only once per design cycle for thelogic being monitored by a counting instrument irrespective of thenumber of simulation cycles utilized to model the design cycle. Thisclocking normalization is necessary to ensure that the event countsrecorded in counters 421 correspond directly to the number of designcycles the event occurred in and not the number of simulator cycles theevent occurred in. For example if an event occurs in two design cycleswhere design cycle require four simulators cycles, it is preferable tohave the event counter reflect a value of two rather than a value ofeight as would occur if the counter were allowed to update in everysimulator cycle.

Furthermore, if the count event being monitored is within a portion ofthe logic with a run-time selectable frequency of operation, it isuseful to have the count registers reflect the number of occurrences ofthe event in terms of design cycles. For example, consider acircumstance where a count event occurs twice during two differentsimulation runs. In the first run, assume that four simulator cycles areneeded to represent each design cycle. Further assume in the second runthat twelve simulator cycles are necessary to represent each designcycle. Without a clocking normalization mechanism, the first run wouldindicate that the event occurred eight times (two occurrences times foursimulator cycles per occurrence) and the second run would indicate thatthe event occurred twenty-four times (two occurrences times twelvesimulator cycles per occurrence) when in fact the event actually onlyoccurred twice in both simulation runs. Therefore, it would beadvantageous to limit the updating of counters 421 such that eachcounter is only updated once per design cycle irrespective of the numberof simulator cycles, possibly variable at run-time, needed to representa design cycle.

In simulation models in which multiple simulator cycles are utilized torepresent a single design cycle, explicit clocking signals are utilizedwithin the model to control the updating of the various design storageelements. These clocking signals specify in which simulator cycles thesimulator latches representing design storage elements are allowed toupdate. A clocking signal is asserted high for some contiguous number ofsimulator cycles at either the beginning or end of the design cycle andasserted low for the remaining simulator cycles within the design cycle.If the clocking signal is asserted high during the beginning of thedesign cycle, the clock is referred to as a “high-active” clock and,likewise, if the clocking signal is asserted low during the beginning ofthe design cycle, the clock is referred to as a “low-active” clock.

Each count event signal has an associated qualifying signal as specifiedby counter declaration comments 455 as described above. Typically, thesequalifying signals are connected to the clocking signals within thedesign responsible for updating the storage elements within the portionof logic monitored by the count event. The qualifying signal for thecount event for simulator latch 600, qualifying signal 612, is depictedas a high-active qualifier signal. Qualifying signal 612 is processed bysimulator latch 613 and logical AND gate 614, to produce signal 610which is active high for one and only one simulator cycle within thedesign cycle delineated by qualifying signal 612.

Still referring to FIG. 5, incrementer 604 represents but one possiblemechanism that may be utilized to implement the next logic state for agiven counter within the present invention. As depicted in FIG. 5,incrementer 604 ensures that counters 421 within a model are cycledthrough a series of values whose binary patterns correspond to thecustomary representation of non-negative integers. In one embodiment ofthe present invention, incrementer 604 is comprised of an adder thatincrements the current value of counter 600 by a unit value each timesignal 605 is selected by selector signal 602. This exemplaryimplementation provides for convenience of decoding the value of counter600 at the termination of a simulation run, but does so at a cost inoverhead that is not acceptable in many simulators.

For software simulators, one of two basic approaches maybe utilized tomodel an incrementer, such as incrementer 604. In the first approach,the incrementer is modeled directly by an ADD or INCREMENT instructionin the simulation execution model. When incrementers are modeleddirectly as a single instruction within the simulation execution model,the use of incrementer 604 provides for efficient counters within asimulation execution model.

The present invention discloses a method and system for naming eventswithin a simulation model that prevents name collisions between eventsin different instrumentation entities, allows for the arbitrary re-useof components of a model in models of arbitrarily increasing size, andfurthermore allows for processing designated events in a hierarchical ornon-hierarchical manner.

When all instances of an event are considered as a whole without regardto specific instances, the event is considered in a “non-hierarchical”sense. Likewise, when an event is considered with regard to each andevery instance, it is considered in a “hierarchical” sense. Whenconsidering count events, for example, it is often convenient to trackthe number of times a particular count event occurred in the aggregatewithout concern to exactly how many times the count event occurred ineach particular instance within a simulation model.

Each type of event: count, fail, and harvest, is given a separate eventnamespace by construction. Each event class is therefore an independentgroup preventing naming collisions between the event types. The datastructure of the present invention is independently applied to each ofthe different event types to ensure correctness within each event class.

In the embodiments illustrated in FIGS. 6A, 6B, 6C, and 6D, the systemand method of the present invention are described with respect to countevents. One skilled in the art will appreciate and understand theextensions necessary to apply the same techniques to other event classessuch as failures or harvests. With reference to FIG. 6A, there isdepicted a block diagram representation of simulation model 1000containing a number of design and instrumentation entities. Asillustrated in FIG. 6A, simulation model 1000 includes two instances ofa design entity X, with instance names X1 and X2 respectively.

Within each of design entity instances X1 and X2 is instantiated aninstance of an instrumentation entity B3, 1012 a and 1012 b. Designentity instances X1 and X2 further comprise instances, 1014 a and 1014b, respectively, of design entity Z which further contains instances,1016 a and 1016 b, of instrumentation entity B1 and instances, 1018 aand 1018 b, of instrumentation entity B2.

Finally, simulation model 1000 includes an instance of design entity Y,with instance name Y, containing an instance of instrumentation entityB4 1022. Design entity instance Y contains an instance, 1024, of designentity Z with further instances, 1016 c and 1018 c, of instrumentationentities B1 and B2 respectively.

In what follows the methods of the present invention for uniquely namingevents will be considered in the context of exemplary model 1000. Itwill be assumed in the following description that each instrumentationentity (B1, B2, B3, and B4) has declared a single count event with eventname “count1”.

In accordance with the method and system of the present invention, theuser must uniquely name each type of event (count, fail, or harvest)within a specific instrumentation entity, i.e., the user cannot declareany two events of the same type within the same instrumentation entitywith the same eventname. Such a constraint does not conflict with thestated goals of the present invention in that a given instrumentationentity is usually created by a specific person at a specific point intime, and maintaining unique names within such a limited circumstancepresents only a moderate burden to the user. The data structuredisclosed herein does, however, prevent all name collisions betweenevents in different instrumentation entities, and allows for processingthe events in a hierarchical and/or non-hierarchical manner.

As previously explained, an HDL naming convention must uniquely identifyall the entities within a given design. This constraint is inherent toHDLs and applies to design entities as well as instrumentation entities.In accordance with conventional VHDL entity naming constructs, it istechnically possible for two design entities to share the same entityname, entity_name. However, such identically named entities must beencapsulated within a VHDL library from which a valid VHDL model may beconstructed. In such a circumstance, entity_name, as it is utilizedherein, is equivalent to the VHDL library name concatenated by a period(“.”) to the entity name as declared in the entity declaration.

Pre-pending a distinct VHDL library name to the entity namedisambiguates entities sharing the same entity name. Most HDLs include amechanism such as this for uniquely naming each design entity. Designentities must be unambiguously named in order to determine whichparticular entity is called for in any given instance in a simulationmodel. The present invention employs the prevailing naming mechanism ofthe native HDL to assign unique entity names for design entitiesthroughout a given model and leverages the uniqueness property of entitynames and the uniqueness of each instance's instantiation identifier tocreate an “extended event identifier” for each event within thesimulation model.

With reference to FIG. 6B, there is illustrated a representation of thefields in an extended event identifier data structure, alternativelyreferred to herein as an “event list”, in accordance with one embodimentof the present invention. The extended event identifier begins withinstantiation identifier field 1030. This field, as describedhereinbefore, is formed of the instance identifiers, proceeding from thetop level entity to the direct ancestor of the given instance within thesimulation model separated by periods (“.”). This string is unique foreach and every instance of the event within the model. The extendedevent identifier further includes an instrumentation entity field 1032,a design entity field 1034, and an eventname field 1036.

Instrumentation entity field 1032 contains the name of theinstrumentation entity (or the name assigned to an embeddedinstrumentation entity) that generates the simulation event. Designentity field 1034 contains the entity name of the design entity in whichthe event occurs. Eventname field 1036 is the name given to the event inthe instrumentation entity description comments of an instrumentationentity or the event name assigned to an event within an embeddedinstrumentation entity. These four namespace fields comprise a uniqueidentifier for each event within a simulation model that allows for there-use of components within other models without risk of name collisionsand the consideration of events in a hierarchical or non-hierarchicalsense.

With reference now to FIG.6C, there is shown a list of extended eventidentifiers for model 1000. Event identifiers 1040, 1041, 1042, 1043,1044, 1045, 1046, 1047, and 1048 are declared within simulation model1000 to designate count events having eventname “count1”. The extendedevent identification procedure of the present invention will bedescribed in the context of these extended event identifiers.

The uniqueness of the names in design entity name field 1034 is aprimary distinguishing factor between events. By including the designentity name in the extended event identifier, each design entity is, ineffect, given a unique namespace for the events associated with thatdesign entity, i.e., events within a given design entity cannot havename collisions with events associated with other design entities.

It is still possible however, to have name collisions between eventsdefined by different instrumentation entities that are incorporatedwithin a single design entity. Events 1041 and 1042, for example, ifidentified solely by the design entity name, have a name collision. Bothare events with eventname “count1” within design entity Z, and iflabeled as such, are indistinguishable. In order to alleviate a namingcollision between events 1041 and 1042, the present invention employsinstrumentation entity field 1032. By referencing the design entity andinstrumentation entity names, both of which are unique with respect tothemselves and each other, a unique event namespace is created for eachinstrumentation entity associated with any given design entity. Forexample, event identifier 1041 and 1042 would be in conflict (both namedZ.count1), unless the respective instrumentation entity names areincluded within the extended event identifier to produce namesB1.Z.count1 and B2.Z.count2 for these events.

It should be noted that it is possible to uniquely name each event byusing instrumentation entity name field 1032 alone. Due to theuniqueness property of instrumentation entity names, event names thatare only named by the instrumentation entity name and the event namefield will be necessarily unique.

However, such a naming scheme is insufficient for associating eventswith a given design entity. In practice, it is desirable to associateevents with the design entity in which they occur rather thanassociating them with the potentially numerous instrumentation entitiesthat are utilized to track them. Moreover, referencing the appropriatedesign entity within the eventname allows all the events associated witha given design entity to be centrally referenced without the need toascertain the names of all the instrumentation entities associated withthe given design entity. The data structure of the present inventionutilizes both the instrumentation entity and design entity names innaming events for ease of reference at the cost of moderate uniquenessredundancy in the event names.

In an alternative embodiment of the present invention, theinstrumentation entity name is not included within the extended eventidentifier. Referring to FIG. 6D, such an alternative extended eventidentification data structure is depicted. As shown in FIG. 6D, eventsare named by instantiation identifier field 1030, design entity namefield 1034, and event name field 1036.

Such a data structure provides name collision protection between designentities but not within design entities. That is, the user must ensurethat events names for events associated with a given design entity donot collide. In case of user error in this regard, model build tools maybe utilized to detect an event name collision condition during modelcompilation. The alternative data structure depicted in FIG. 6D providesfor simpler naming and referencing of events at the expense of requiringthe user to prevent name collisions for events associated with a givendesign entity.

Returning to FIG. 6B, the combination of instrumentation entity field1032, design entity name field 1034, and eventname field 1036 for agiven event, provides a unique identifier for any given event withoutregard to multiple instantiations of the event. In order to uniquelydistinguish between multiple instantiations of an event, instantiationidentifier field 1030 is included in the extended event identifier.Instantiation identifier field 1030 field, by its construction, providesa unique string for any instance of an entity within any simulationmodel.

When evaluating occurrences of an event in a non-hierarchical sense,instantiation identifier field 1030 is ignored while searching formatching events. As illustrated in FIG. 6C, for example, anon-hierarchical query for the number of time a “count1” event occurswithin design entity Z as detected by instrumentation entity B1,utilizes the following list of count eventnames:

X1.Z B1 Z COUNT1 X2.Z B1 Z COUNT1 Y.Z B1 Z COUNT1.

These count events are added together to form an aggregate count of thetotal number of time the specific event occurred within the simulationmodel.

A hierarchical query includes specific criteria to match against thehierarchy field to limit the counter or counters found to specificinstances of the requested event. For example, a query to obtain thecount1 event of instrumentation entity B1 within the X1.Z instance ofdesign entity Z utilizes the following count eventname:

-   -   X1.Z B1 Z COUNT1, which represents the number of times the        count1 event was counted by instrumentation entity B1 within        design entity instance X1.Z for a particular simulation        interval.

By providing matching model hierarchy criteria against instantiationidentifier field 1030, it is possible to consider the events withrespect to their particular instance or instances within the model,i.e., a hierarchical query. A non-hierarchical query merely ignores thehierarchy field and returns all the instances of the requested eventswithin the model.

With reference to FIG. 7A, there is depicted a block diagramillustrating a simulation model 1100 in which the hierarchical eventprocessing of the present invention is applicable. Simulation model 1100comprises a top-level design entity 1130 in which a pair of lower-leveldesign entities 1102 and 1120 is instantiated. A design entity 1104containing instrumentation entity 1106 is included within design entity1102. As illustrated in FIG. 7A, instrumentation entity 1106 includeslogic 1110 for generating a simulation event 1108 from signal set 1132from within design entity 1104. Design entity 1120 includes aninstrumentation entity 1122 that generates a simulation event 1124 usingsignal set 1134.

Utilizing the techniques described hereinbefore, generating ahierarchical event that is some logical combination of events 1108 and1124 requires the creation of an instrumentation entity associated withtop level design entity 1130 that references signal sets 1132 and 1134.Conventionally, such an instrumentation entity would substantiallyreproduce instrumentation logic 1110 and 1126 to process signal sets1132 and 1134, respectively, thus producing a copy of events 1108 and1124. Such a procedure is inefficient and prone to error. If, forexample, changes are made to any or all of signal sets 1132 and 1134, orinstrumentation logic 1110 and 1126, these changes would have to beaccurately repeated in the instrumentation entity logic for the combinedevent.

The present invention provides a mechanism whereby events, such asevents 1108 and 1124, are directly referenced and utilized as inputs tocross-hierarchical instrumentation entities. In this manner, signalconnections 1132 and 1134, as well as instrumentation logic 1110 and1126, are directly re-utilized to produce the desired hierarchicalevent.

To facilitate direct referencing of events within simulation models, aspecialized data structure is implemented within instrumentation entityinput port map comment syntax. This data structure directly connectsinput ports of instrumentation entities to cross-hierarchical eventswithin a simulation model.

For the embodiment depicted in FIG. 7A, an instrumentation entity 1150is instantiated within top-level design entity 1130 to generate ahierarchical event 1156 that is some function of events 1108 and 1124.As illustrated in FIG. 7A, instrumentation entity 1150 includes a pairof inputs 1151 and 1152 that are directly connected to events 1124 and1108, respectively, utilizing the augmented syntax described below.These input connections are logically combined using instrumentationlogic 1154 to produce a cross-hierarchical event 1156.

With reference to FIG. 7B, there is depicted a set of input port mappingcomments for performing cross-hierarchical processing of simulationmodel events in accordance with the teachings of the present invention.In what follows, it is assumed that events 1108 and 1124 are countevents with event names event_1108 and event_1124, respectively, andthat these events are connected to input ports event_1108 _(—) in andevent_1124 _(—) in on instrumentation entity 1150. As depicted in FIG.7B, a first input port mapping comment 1161 contains data forreferencing event 1108 to input port event_1108 _(—) in. A second inputport mapping comment 1162 contains data for referencing event 1124 toinput port event_1124 _(—) in. It should be noted that each of inputport mapping comments 1161 and 1162 includes a pre-pendednon-conventional comment identifier, --!!, that is utilized by the HDLcompiler (such as compiler 462 in FIG. 3D) to maintain the port mappingcomments separate from the design.

To facilitate connection of a simulation event to an instrumentationentity input port, input port mapping comments 1161 and 1162 includestwo distinct parts: an instance identifier and an event identifier. Theinstance identifier is a string built from instance names (in descendinghierarchical order) of all design entities between and including thedesign entity containing the instrumentation entity of thecross-hierarchical event being defined (i.e., the highest level designentity for the cross-hierarchical event), and the design entity in whichthe event that is utilized in generating the cross-hierarchical event.If the design entity containing the hierarchical event is the same asthe design entity containing the event to be connected to, the instanceidentifier is a null string. A pair of instance identifiers 1163 and1164, within input port mapping comments 1161 and 1162, respectively,specify that events 1124 and 1108 originate from signals within designentity 1120 and 1104 respectively.

Input port mapping comments 1161 and 1162 further include eventidentifiers 1165 and 1166, that identify input simulation events interms of local instrumentation entities 1106 and 1122, respectively. Inaccordance with the embodiment depicted in FIG. 7B, each eventidentifier is a string beginning with an open bracket (“[”) characterand ending with a closed bracket (“]”) character. Between thesebrackets, three sub-strings, delineated by period (“.”) characters,comprise a data structure utilized to identify a specific event fromwhich the cross-hierarchical event is defined. The first sub-stringwithin an event identifier is the instance name of the instrumentationentity containing the event. The second sub-string is a stringspecifying the type of the event (“count”, “fail”, or “harvest”).Finally, the third sub-string is the event name of the given event asspecified in the declaration comment for the event. Each eventidentifier string uniquely identifies a single event within a givendesign entity. As depicted in FIG. 7B, event identifier strings 1165 and1166 identify events 1108 and 1124 respectively.

In accordance with an alternate embodiment of the present invention, theevent identifier naming structure is modified slightly for events thatare labeled in accordance with FIG. 6D (event names that do not includethe instrumentation entity name). When an instrumentation identifier isabsent from the extended event identifier, the event identifier stringwith an input port mapping comment includes two sub-strings: a stringdenoting the type of event to connect to; and a string providing thename of the event separated by a period (“.”) character. Theinstrumentation entity name is not required in this case since allevents of a given type associated with a given design entity will haveunique names. The model build tools of the present invention willautomatically search all instrumentation entities associated with thedesign entity called out by the instance identifier to determine whichinstrumentation entity generates an event having the name and typeprovided in the event identifier string.

Referring to FIG. 7C, there is illustrated a set of data structures forperforming hierarchical processing of simulation model events inaccordance with a second embodiment of the present invention. In thedepicted embodiment, a pair of input port mapping comments 1171 and 1172employs a syntax compatible with the event naming data structuredepicted in FIG. 6D.

Input port mapping comment 1171 connects event 1108 to input portevent_1108 _(—) in on instrumentation entity 1150. Likewise, input portmapping comment 1172 connects event 1124 to input port event_1124 _(—)in on instrumentation entity 1150. By utilizing the augmented syntax ofFIG. 7B or FIG. 7C, it is possible to create hierarchical events byconnecting the inputs of instrumentation entities to events within thesimulation model.

The above described system and method provides for practicalinstrumentation of simulation models and allows for efficientimplementation of instrumentation logic through embedded instrumentationentities. Embedded instrumentation entities, as described hereinabove,are however necessarily limited to task-specific implementations. Asdescribed with reference to FIGS. 8A and 8B, the present inventionfurther provides for a more flexible implementation of instrumentationlogic in a more unstructured manner.

It is often necessary to tailor instrumentation logic to address uniqueproblems and circumstances. Instrumentation logic of a specific and yetnon-predefined nature that is designed in accordance with the techniquesdisclosed herein with reference to FIGS. 8A and 8B is referred herein as“random instrumentation logic.” A data construct including general logicprimitives (Boolean operators, storage elements, etc.) and aninterconnection method for these primitives is utilized for implementingsuch random instrumentation logic.

For instrumenting a simulation model as described heretofore, an HDLsuch as VHDL or Verilog is utilized as a platform from whichinstrumentation logic is generated. Appropriate instrumentation entitydescriptor comments within design entity source code files couple theresultant instrumentation entities to designated target design entitieswithin a simulation model.

In addition to entity descriptor comments within a design entity sourcecode file, the foregoing instrumentation technique requires a separateHDL file in which the instrumentation entity is described. As explainedwith reference to FIGS. 8A and 8B, the present invention provides amethod, system, and data structure for instrumenting design entitieswithin a simulation model while avoiding the design process overheadrequired for creating a separate instrumentation entity HDL file.

In accordance with the teachings of the present invention, randominstrumentation logic is directly deployed within target design entitiesin terms of individualized and customizable instrumentation descriptorcomments. Such instrumentation descriptor comments are encoded withinthe target design entity HDL source code file and provide a means forthe describing random instrumentation logic, events, andinterconnections between the created instrumentation logic and thetarget design entity. The random instrumentation logic is inserted intothe simulation model in a manner similar to the techniques used forembedded instrumentation entities to produce an instrumentation entitywithout the need for the creation of an explicit HDL instrumentationentity file.

With reference to FIG. 8A, there is illustrated a representative targetdesign entity 1200 wherein random instrumentation logic is implementedin accordance with a preferred embodiment of the present invention.Instantiated within target design entity 1200 is a design entity 1201.As further depicted in FIG. 8A, an instrumentation entity 1202 isinstantiated within design entity 1201. Instrumentation entity 1202 isdesigned in accordance with the principles set forth hereinabove togenerate a count event 1203 having an event name “count1.” Target designentity 1200 further includes an instrumentation entity 1208 that isgenerated utilizing random instrumentation logic. As depicted in FIG.8A, instrumentation entity 1208 receives as inputs signals P, A, B, andC along with count event 1203.

Instrumentation entity 1208 is constructed by a set of unconventionalcomments lines within the source code file for target design entity1200. These comments may be incorporated at any point within the logicdescription section of the HDL source code file. HDL compiler 462 (FIG.3B) recognizes the unconventional comments in addition to any commentsutilized to instantiate embedded instrumentation entities within designentity 1200. During the post-compilation/model build phase,instrumentation load tool 464 processes these comments in a mannersimilar to that utilized for embedded instrumentation entities(described with reference to FIGS. 6A-6D) to generate instrumentationentity 1208.

A variety of possible syntaxes can be utilized to formulate theunconventional HDL comments required for generating randominstrumentation logic within the source code file of a target designentity. As depicted in FIG. 8B, much of the syntax of these commentsemploys syntax similar to the concurrent subset of the VHDL languagewith the addition of syntactic and semantic enhancements that provide ameans of connection between an instrumentation entity and its targetdesign entity. In addition, minor syntactic and semantic enhancementsare provided to declare events and intermediate signals.

With reference now to FIG. 8B, there is illustrated an exemplary HDLsource code file 1220 that describes design entity 1200. Within HDLsource code file 1220, an entity instantiation 1221 produces designentity 1201, and assignment statements 1222 are utilized to generatesignals A, B, and C. A set of unconventional comments 1223 within HDLsource code file 1220 is utilized to produce instrumentation entity1208. Comments 1223 are formulated as left-hand side (l.h.s.)/right-handside (r.h.s.) assignment statements of the form:

-   -   {l.h.s.}<={r.h.s.};        where {l.h.s.}, referred to herein after as lhs, is the        assignment statement target and, {r.h.s}, referred to herein        after as rhs is an expression denoting the logical value to be        assigned to the statement lhs. A number of rules delineate the        possible expressions for lhs and rhs in any legal statement in        the instrumentation comments.

As employed within the instrumentation data structure of the presentinvention, an lhs statement may be either an event declaration or thename of a signal that is instantiated within an instrumentation entity.An event declaration is an expression with in bracket characters (“[A,A]”) that generates a new event. Within comments 1223, a statement 1230produces a count event 1240 from instrumentation entity 1208 (FIG. 8A)having eventname “countname0”.

Within an lhs event declaration, a first field designates the event type(count, fail, harvest, etc.) and is followed by such other fields as arenecessary to declare the event. As illustrated in lines 1230, 1234, and1236, such event declaration fields follow the same format as the eventdeclaration fields depicted in FIG. 3C.

Comments 1223 further include a line 1232 having an lhs that declares asignal Q within instrumentation entity 1208. To prevent ambiguity, anysignal declared in this manner may not have a name corresponding to thename of any signal present on the top level of target design entity1200. Conformance to this requirement is verified by instrumentationload tool 464 (FIG. 3D) during processing. Signals declared by an lhsexpression may be incorporated within an rhs expression as shown inlines 1232 and 1234.

An rhs includes logical connectivity expressions and/or functions thatcombine various signals. Signals within these connectivity expressionsmay originate from a number of possible sources including: signalsdeclared on the lhs of a statement in the instrumentation comments;signals within the target design entity; or signals designating otherevents within the target design entity.

The absence of period (“.”) or bracket (“[”, “]”) characters within asignal value description in the rhs of a statement, designates theobject signal as corresponding to either a signal within the tophierarchical level of the target design entity or to a signal declaredon the lhs of a statement within the instrumentation language. Signalsare named in a mutually exclusive manner by the rules governing creationof signals on the lhs of a statement in the instrumentation comments,thereby preventing any ambiguity in the determining the source of thegiven signal.

Signals in rhs connectivity expressions can also be connections tosignals within entities instantiated within the target design entity. Insuch a circumstance, the instance names of the entity or entities in thehierarchy enclosing the desired signal are placed before the signal namein hierarchy order, delineated by period (“.”) characters. For example,the signal in statement 1230 (“Y.P”) represents signal 1204 withindesign entity 1201. Signals at any level of the target design hierarchyare thus accessible to instrumentation logic generated by theinstrumentation language comments.

Signals within the instrumentation comment expressions can alsodesignate other events within the target entity. Event identifiers asdescribed hereinbefore for hierarchical events are used to denote such“event” signals. For example, statement 1232 performs a logical AND ofinstrumentation event 1203 and signal A. The event identifier“Y.[B1.count.count1]” connects instrumentation entity 1208 toinstrumentation event 1203. This notation permits instrumentation eventsat any level of design hierarchy within target design entity 1200 to bedirectly accessed.

As further depicted in FIG. 8B, statement 1232 produces intermediatesignal Q within instrumentation entity 1208. This is an example of aninstrumentation comment statement declaring a new intermediate signal.These signals can be used in other statements to construct randominstrumentation logic of any desired depth or complexity.

Statement 1234 utilizes intermediate signal Q along with signal 1206 toproduce fail event 1241. The syntax for fail event declaration includesa field denoting the type of event (“fail”), a field giving the eventname for the fail event (“failname0”), and a final field denoting themessage to associate with the fail. Finally, statement 1236 producesharvest event 1242.

In general, the rhs expression of any statement in the instrumentationdata structure of the present invention can access any signal orinstrumentation event signal within the target design entity utilizingthese syntactic mechanisms. These signals can be combined to form newevents or intermediate signals that can themselves be further combinedto form instrumentation logic of any desired depth or complexity.

Instrumentation comments can be placed anywhere within the logicdescription section of the target entity source code file. Allinstrumentation comments within a file are considered as a whole andproduce a single instrumentation entity within the target design entity.

The inclusion of instrumentation logic within a simulation executablemodel as described herein leads to an increase in the size of thesimulation executable model and a concomitant increase in the timerequired to process a simulation run. With smaller simulation models,the decrease in simulation performance attributable to instrumentationlogic is not significant. However, as larger simulation models arehierarchically constructed from smaller models, the simulation overheadattributable to the instrumentation logic can become significant.Accordingly, the present invention permits the processing overheadattributable to instrumentation logic to be reduced by selectivelyremoving instrumentation events and associated logic elements from asimulation model prior to simulation.

To remove selected event instances and associated logic elements fromthe simulation model, a list of event instances that are to be removedfrom the simulation model are identified in an exclusion list, which maybe provided, for example, in one or more exclusion files 443 (FIG. 3D).With reference now to FIG. 9A, there is illustrated an exemplaryembodiment of an exclusion file 443 in accordance with the presentinvention. As shown, exclusion file 443 contains a plurality of entries1304 including entries 1304 a-1304 d. Each of entries 1304 includes fivefields 1302 a-1302 e, the first four of which respectively correspond tothe instantiation identifier, instrumentation entity name, design entityname and eventname fields 1030-1036 of FIG. 6B (of course, entries 1304may alternatively include fields corresponding to those illustrated inFIG. 6D). Field 1302 e further indicates the type(s) of events (e.g.,count, harvest, fail, etc.) identified by each entry 1304.

The information within fields 1302 a-1302 e identifies one or moreevents or event instances to be removed from the simulation model. Forexample, entry 1304 a is intended to remove all instances of an event orevents named “event1” associated with a design entity named “design1”.Entry 1304 b identifies for removal a specific instance of a count eventnamed “event2” within the instrumentation entity “inst2” that isassociated with the instance of design entity “design1” occurring at x.yin the model hierarchy. Entry 1304 c is intended to remove all failevents associated with all instances of instrumentation entity “inst3”.Finally, entry 1304 d is intended to remove all harvest eventsassociated with all instances of design entity “design2”. Thus,exclusion file 443 permits a user, inter alia, to stipulate the removalof all instances of a particular instrumentation event, removal of oneor more instances of an instrumentation event, removal of all instancesof all events associated with instances of one or more instrumentationentities, or removal of all instances of all events associated withinstances of one or more design entities.

Referring now to FIGS. 9B, there is depicted an exemplaryinstrumentation entity 1310 from which an event instance and itsassociated logic may be selectively removed in accordance with thepresent invention. Instrumentation entity 1310 maybe, for example, aninstrumentation entity 409 (FIG. 3A) generated from an HDLinstrumentation file 440 or an instrumentation entity 1208 (FIG. 8A)containing random instrumentation logic generated from statements 1223embedded within an HDL design entity source code file 1220.

As depicted, instrumentation entity 1310 contains a number of boundarymarkers 1314 a-1314 f demarking the boundary between instrumentationentity 1310 and the input signals 1312 received from the target entity.Each boundary marker 1314 merely passes its input signal through to itsoutput unaffected. Boundary markers 1314 are preferably inserted intoeach instrumentation entity proto data structure 466 by instrumentationload tool 464 or model preprocessor 445 prior to the flattening of thesimulation model by model preprocessor 445. This implementationadvantageously permits boundary markers 1314 to be applied to eachinstrumentation entity once. It will be appreciated that modelpreprocessor 445 may alternatively insert boundary markers 1314 duringor after the process of flattening the simulation model through thecreation of discrete instances of each instrumentation entity.

Instrumentation entity 1310 also includes a body section 1320 containingthe logic that generates instrumentation event 1322 a (event(x)) andinstrumentation event 1322 b (event(y)) from input signals 1312. In theexemplary embodiment, body section 1320 includes at least three regions:(1) region 1324 a, which includes logic elements (including latches)that are utilized to generate only instrumentation event instance 1322a, (2) region 1324 b, which contains logic elements that are utilized togenerate both instrumentation event instances 1322 a and 1322 b, and (3)region 1324 c, which includes logic that is utilized to generate onlyinstrumentation event instance 1322 b. Because of the dependency ofinstrumentation event 1322 b on the logic within region 1324 b, only thelogic within region 1324 a can be removed if instrumentation event 1322a is eliminated and instrumentation event 1322 b is retained. Similarly,only the logic within region 1324 c can be removed if instrumentationevent 1322 b is eliminated and instrumentation event 1322 a is retained.

With reference now to FIG. 9C, there is illustrated a high level logicalflowchart of an exemplary method of selective removal of event instancesand associated logic elements from a simulation model in accordance withthe present invention. As a logical flowchart, some or all of theillustrated steps may be performed in an alternative order than thatshown or in parallel. For clarity, FIG. 9C is described with specificreference to instrumentation entity 1310 of FIG. 9B. Further, it will beappreciated from the following description that the process is generallyapplicable to the removal from a simulation model of instrumentationevent instances that do not depend upon other instrumentation eventinstances. In addition, although the depicted process assumes a singleexclusion file 443, it will be appreciated that the process may beextended in a straight forward manner to support an exclusion listformed of multiple exclusion files 443 for a given simulation model.

The process begins at block 1330 and thereafter proceeds to blocks 1332and 1334, which respectively illustrate instrumentation load tool 464 ormodel preprocessor 445 inserting boundary markers 1314 at the inputs ofeach instrumentation entity and model preprocessor 445 flattening thesimulation model, as hereinbefore described. The process then proceedsto blocks 1336-1346, which depict model preprocessor 445 entering aprocessing loop in which model preprocessor 445 processes each entry1304 in exclusion file 443. If model preprocessor 445 determines atblock 1336 that it has processed every entry 1304 in exclusion file 443,the process passes to blocks 1350-1354, which are described below. If,however, model preprocessor 445 determines at block 1336 that one ormore entries 1304 in exclusion file 443 remain to be processed, theprocess passes to block 1338.

Block 1338 depicts model preprocessor 445 determining if allinstrumentation event instances identified by the entry 1304 ofexclusion file 443 currently under consideration have been processed. Ifso, the process returns to block 1336; if not, the process proceeds toblock 1340. At block 1340, model preprocessor 445 marks for deletion alllogic elements (including latches) within the cone of influence of thenext instrumentation event instance to be processed for the currententry 1304 in exclusion file 443. For example, if instrumentation eventinstance 1322 a is identified for deletion by an entry 1304 in exclusionfile 443, model preprocessor 445 marks for deletion all logic elementswithin region 1324 a and 1324 b of body 1320 beginning withinstrumentation event instance 1322 a and tracing backward through allsignal paths through regions 1324 a and 1324 b until a boundary marker1314 is found and marked. Stopping at a boundary marker 1314 ensuresthat logic within the target design entities is not marked for deletionand is therefore preserved. As further illustrated at blocks 1342 and1344, model preprocessor 445 also deletes the external instrumentationlogic (e.g., within external instrumentation logic 420 of FIG. 3B) forthe identified instrumentation event instance and removes theinstrumentation event instance from the event list for the simulationmodel. The process then advances to block 1346, which depicts modelpreprocessor 445 selecting for processing the next instrumentation eventinstance, if any, matching the criteria specified in the current entry1304 of exclusion file 443. The process then returns to block 1338,which has been described.

In order to ensure that logic elements within a region (e.g., region 324of FIG. 9B) shared between a deleted instrumentation event instance anda non-deleted (retained) instrumentation event instance are retained,model preprocessor 445 enters a processing loop comprising blocks1350-1354 in response to a determination at block 1336 that all entries1304 of exclusion file 443 have been processed. Blocks 1350-1354represent removing deletion marks from all logic elements shared betweendeleted and non-deleted event instances. Referring specifically to block1350, model preprocessor 445 determines if all non-deleted eventinstances in the simulation model have been processed. If so, theprocess proceeds to block 1356, which is described below. If, however,at least one non-deleted event instance remains to be processed, theprocess passes to block 1352, which depicts removing deletion marks, ifany, in the cone of influence of the non-deleted event instance. Forexample, if instrumentation event 1322 b is a non-deleted eventinstance, model preprocessor 445 begins with instrumentation eventinstance 1322 b and traces backward through each of its signal pathsremoving deletion marks, if any, until a boundary marker 1314 isreached. Thus, all deletion marks on logic elements within region 1324 bof body 1320 are removed. Thereafter, the process proceeds to block1354, which illustrates model preprocessor 445 advancing to the nextnon-deleted event instance to be processed, if any, within thesimulation model. Thereafter, the process returns to block 1350, whichhas been described.

Block 1356 depicts model preprocessor 445 deleting (removing) from eachinstrumentation entity the logic elements, if any, that remain markedfor deletion following the processing loop comprising blocks 1350-1354.For instrumentation entity 1310 of FIG. 9B, this includes all logicelements (e.g., gates and latches) within region 1324 a. It will beappreciated by those skilled in the art that additional steps beyond thedeletion of logic elements may need to be performed to support theremoval of certain complex event types that may be defined. Suchextensions are within the skill of those of ordinary skill in the artand are accordingly not discussed further herein. Following block 1356,the process of FIG. 9C ends at block 1360 having obtained a more compactsimulation model.

As noted above, the above-described process is sufficient for theremoval of instrumentation logic associated with instances ofinstrumentation events that do not themselves depend upon otherinstrumentation events. However, to additionally support the removal ofinstrumentation logic from simulation models in which simulation eventsare permitted to depend on other instrumentation events, some techniqueis required to ensure that instrumentation logic that is utilized togenerate a non-deleted downstream instance of an instrumentation eventis preserved. One such technique is illustrated in FIGS. 10A-10D anddescribed in detail below.

Referring now to FIGS. 10A-10D, there is depicted a high level logicalflowchart of an exemplary method of selectively removing instrumentationevent instances and associated logic elements from a simulation modelthat permits instrumentation event instances to depend upon othersimulation event instances. As a logical flowchart, it will beappreciated that some or all of the illustrated steps maybe performed inan alternative order than that shown or in parallel. For clarity, FIGS.10A-10D are described with specific reference to the instrumentationentities shown in FIGS. 11A-11D. It will further be appreciated from thefollowing description that the process is generally applicable to theselective removal from a simulation model of instrumentation events andassociated logic elements, even in cases in which one or moreinstrumentation event instances depend upon other instrumentation eventinstances. In addition, although the depicted process assumes a singleexclusion file 443, it will be appreciated that the process maybeextended in a straightforward manner to support an exclusion list formedof multiple exclusion files 443 for a given simulation model.

The depicted process begins at block 1400 of FIG. 10A and thereafterproceeds to block 1402, which illustrates instrumentation load tool 464or model preprocessor 445 inserting a boundary marker at eachinstrumentation entity input coupled to a target design entity. Forexample, as shown in FIG. 11A, boundary markers 1502 a 1 and 1502 a 2are inserted at inputs of instrumentation entity 1500 a , boundarymarkers 1502 b 1 and 1502 b 2 are inserted at inputs of instrumentationentity 1500 b, boundary markers 1502 c 1 and 1502 c 2 are inserted atinputs of instrumentation entity 1500 c and boundary markers 1502 d 1and 1502 d 2 are inserted at inputs of instrumentation entity 1500 d. Asfurther shown at block 1404, model preprocessor 445 flattens thesimulation model in the manner hereinbefore described.

The process then proceeds to block 1410, which depicts modelpreprocessor 445 entering a processing loop in which model preprocessor445 processes the remaining instrumentation entity inputs. Inparticular, model preprocessor 445 determines at block 1410 whether ornot there is at least one additional instrumentation entity input to beprocessed that is attached to an instance of an instrumentation event.If not, the process proceeds through page connector A to FIG. 10B, whichis described below. If, however, at least one additional instrumentationentity input that is attached to a target instrumentation event instancehas not been processed, the process passes to block 1412. Block 1412depicts model preprocessor 445 determining whether or not the targetinstrumentation event instance under consideration is identified withinexclusion file 443 as an event instance to be deleted. If not, modelpreprocessor 445 inserts a boundary marker at the instrumentation entityinput under consideration, as shown at block 1414. For example, asillustrated in FIG. 11A, model preprocessor 445 inserts boundary marker1502 b 3 at the input of instrumentation entity 1500 b connected toinstrumentation event instance 1504 a if exclusion file 443 does notidentify that event instance for deletion. Thereafter, the process ofFIG. 10A returns to block 1410, which has been described.

Returning to block 1412, if model preprocessor 445 determines that thetarget instrumentation event instance of the instrumentation entityinput under consideration is identified for deletion within exclusionfile 443, the process proceeds to block 1420. At block 1420, modelpreprocessor 445 places a connector marker (represented as a diamond inFIGS. 11A-11D) at the instrumentation entity input under consideration.Like boundary markers, connector markers contain no logic elements, butsimply pass their inputs to their outputs. Assuming that instrumentationevent instance 1504 b of FIG. 11A is identified for deletion withinexclusion file 443, model preprocessor 445 inserts connector markers1506 c and 1506 d at the inputs of instrumentation entity 1500 c and1500 d, respectively, that are connected to instrumentation eventinstance 1504 b.

Model preprocessor 445 next determines at block 1422 whether or not acounter marker is present at the target instrumentation event instanceto which the instrumentation entity input under consideration isconnected. Counter markers, like boundary and connector markers, do notcontain any logic that modifies the signals to which they are connected.A counter marker merely indicates the number of downstreaminstrumentation entity inputs directly connected to the instrumentationevent instance to which the counter marker is itself connected. If modelpreprocessor 445 determines at block 1422 that a counter marker ispresent at the target instrumentation event instance, model preprocessor445 increments the count value of the counter marker, as illustrated atblock 1426. Thereafter, the process returns to block 1410, which hasbeen described. If, on the other hand, model preprocessor 445 determinesat block 1422 that no counter marker is present at the targetinstrumentation event instance, as is the case when a particularinstrumentation event instance is first encountered, model preprocessor445 inserts a counter marker at the output of the target instrumentationevent instance connected to the instrumentation event instance underconsideration, as shown at block 1424. Model preprocessor 445 thenincrements the count value of the counter marker established at block1424 to a count value of 1, as depicted at block 1426. Thereafter, theprocess returns to block 1410, which has been described.

In the example of FIG. 11A, the operations depicted at block 1420-1426of FIG. 10A result in the insertion of counter marker 1508 b at theoutput of instrumentation entity instance 1500 b, which is connected toinstrumentation event instance 1504 b 2. Counter marker 1508 bultimately has a count value of 2 based upon the connection of inputs ofinstrumentation entities 1500 c and 1500 d to target instrumentationevent instance 1504 b 2.

Referring now to FIG. 10B, the process begins at page connector A andthen proceeds to blocks 1430-1442, which depict model preprocessor 445entering a processing loop in which model preprocessor 445 processeseach entry 1304 in exclusion file 443. If model preprocessor 445determines at block 1430 that it has processed every entry 1304 inexclusion file 443, the process passes to blocks 1450-1454, which aredescribed below. If, however, model preprocessor 445 determines at block1430 that one or more entries 1304 in exclusion file 443 remain to beprocessed, the process passes to block 1432.

Block 1432 depicts model preprocessor 445 determining if allinstrumentation event instances identified by the entry 1304 ofexclusion file 443 currently under consideration have been processed. Ifso, the process returns to block 1430; if not, the process proceeds toblocks 1434 and 1436. At block 1434, model preprocessor 445 deletes theexternal instrumentation logic (e.g., within external instrumentationlogic 420 of FIG. 3B) for the next instrumentation event instance to beremoved and, at block 1436, removes the instrumentation event instancefrom the event list for the simulation model. Model preprocessor 445further determines at block 1438 whether the logic elements in theinstrumentation entity that are utilized to generate the removedinstrumentation event instance can be marked for deletion. In thedepicted embodiment, model preprocessor 445 makes this determinationbased upon whether the removed instrumentation event instance has anassociated counter marker. If so, at least one downstreaminstrumentation event instance still depends upon the logic elementsthat generate the removed instrumentation event instance, and the logicelements therefore cannot be marked for deletion. The processaccordingly passes to block 1442. If model preprocessor 445 determinesat block 1438 that no counter marker is present at the removedinstrumentation event instance, the process proceeds to block 1440.Block 1440 depicts model preprocessor 445 marking for deletion all logicelements (including latches) within the cone of influence of the removedinstrumentation event instance up to and including any boundary orconnector markers of the instrumentation entity. The process thenadvances to block 1442, which depicts model preprocessor 445 selectingfor processing the next instrumentation event instance, if any, matchingthe criteria specified in the current entry 1304 of exclusion file 443.The process then returns to block 1432, which has been described.

Returning to block 1430, if model preprocessor 445 determines that ithas processed every entry 1304 in exclusion file 443, the process passesto blocks 1450-1454. Blocks 1450-1454 represent removing deletion marksfrom all logic elements shared between deleted and non-deletedinstrumentation event instances. Referring specifically to block 1450,model preprocessor 445 determines if all non-deleted event instances inthe simulation model have been processed. If so, the process proceedsthrough page connector B to block 1460 of FIG. 10C, which is describedbelow. If, however, at least one non-deleted instrumentation eventinstance remains to be processed, the process passes to block 1452,which depicts model preprocessor 445 removing deletion marks, if any, inthe cone of influence of the non-deleted instrumentation event instance.The removal process includes the removal of deletion marks, if any, fromconnection and boundary markers. Thereafter, the process proceeds toblock 1454, which illustrates model preprocessor 445 advancing to thenext non-deleted instrumentation event instance to be processed, if any,within the simulation model. Thereafter, the process returns to block1450, which has been described.

With reference now to block 1460 of FIG. 10C, the process then enters aprocessing loop in which logic elements marked for deletion areprogressively removed from the simulation model as dependencies betweeninstrumentation event instances are eliminated. At block 1460, modelpreprocessor 445 determines whether any logic elements that are markedfor deletion remain in the simulation model. If not, the process passesto block 1480, which is described below. If, however, model preprocessor445 determines at block 1460 that at least one logic element marked fordeletion remains in the simulation model, the process proceeds to block1462, which illustrates model preprocessor 445 making a fartherdetermination if the next logic element marked for deletion is aconnector marker. If not, model preprocessor 445 removes from thesimulation model the logic element under consideration and its inputpins, if any. The process then returns to block 1460.

Returning to block 1462, in response to model preprocessor 445determining that the logic element marked for deletion is a connectormarker, model preprocessor 445 determines at block 1470 if the countvalue of the associated counter marker is equal to 1. If not, modelpreprocessor 445 decrements the count value of the associated countermarker 1508, as shown at block 1476. In addition, model preprocessor 445removes the connector marker 1506 and its associated input pin.Thereafter, the process returns to block 1460, which has been described.

Returning to block 1470, if the count value of the counter marker 1508associated with the connector marker 1506 marked for deletion is equalto 1, model preprocessor 445 replaces the counter marker 1508 with arepresentation of a wire (block 1472) and enqueues a deletion pointer tothat wire within a deletion pointer list. Thereafter, the processproceeds to block 1478, which has been described. For example, FIG. 11Bdepicts an exemplary scenario in which instrumentation event instances1504 c 2 and 1504 d 1 and their respective associated logic elementshave been removed from the simulation model, counter marker 1508 b hasbeen replaced with a wire in accordance with block 1472, and a deletionlist 1520 containing a deletion pointer 1522 identifying the replacementwire has been created. Deletion pointer 1522 identifies the wire and itsassociated logic elements for deletion in a subsequent pass of theprocess beginning at block 1480, which is described below.

Referring now to block 1480, model preprocessor 445 determines whetheror not the deletion pointer list (e.g., deletion pointer list 1520 ofFIG. 11B) is empty. If not, the process passes through page connector Cto blocks 1490-1494 of FIG. 10D, which represent model preprocessor 445entering a processing loop in which model preprocessor 445 marks logicelements within selected instrumentation entity instances for deletionby reference to deletion pointer list 1520. In particular, at block 1490model preprocessor 445 selects a first or next deletion pointer 1522from deletion pointer list 1520 and marks for deletion all logicelements of the instrumentation entity that are within the cone ofinfluence of the signal (wire) identified by the deletion pointer 1522.As indicated at blocks 1492 and 1494, this process continues until alldeletion pointers 1522 within deletion pointer list 1520 have beenprocessed.

In response to model preprocessor 445 determining at block 1492 thatdeletion pointers 1522 within deletion pointer list 1520 have beenprocessed, model preprocessor 445 then enters another processing loopcomprising blocks 1495, 1497 and 1498 in which model preprocessor 445removes the deletion marks associated with logic elements utilized togenerate non-deleted instrumentation event instances. In particular, atblock 1495 model preprocessor 445 determines if all non-deleted eventinstances in the simulation model have been processed. If so, modelpreprocessor 445 deletes deletion pointer list 1520, as shown at block1496, and the process proceeds through page connector B to block 1460 ofFIG. 10C, which has been described. If, however, at least onenon-deleted instrumentation event instance remains to be processed, theprocess passes to block 1497, which depicts model preprocessor 445removing deletion marks, if any, in the cone of influence of thenon-deleted instrumentation event instance. The removal process includesthe removal of deletion marks, if any, from connection and boundarymarkers. Thereafter, the process proceeds to block 1498, whichillustrates model preprocessor 445 advancing to the next non-deletedinstrumentation event instance to be processed, if any, within thesimulation model. Thereafter, the process returns to block 1495, whichhas been described.

As depicted in FIG. 11C, the process steps shown at blocs 1480-1498remove the wire identified by deletion pointer 1522 and all logicelements within its cone of influence (up to and including boundarymarker 1502 b 3) that do not also fall within the cone of influence ofnon-deleted instrumentation event instances 1504 b 1 and 1504 b 3. Inaddition, deletion pointer list 1520 is deleted, as described withrespect to block 1496.

Returning to block 1480 of FIG. 10C, if model preprocessor 445determines that the deletion pointer list 1520 is empty, meaning that noadditional logic elements can be removed from the simulation model,model preprocessor 445 scans the simulation model for emptyinstrumentation entity instances containing no logic elements (block1482). Any such “empty” instrumentation entity instances are deleted tofurther compact the simulation model. For example, FIG. 11D illustratesthe deletion of instrumentation entity instance 1500 d. Thereafter, theprocess ends at block 1484.

It will be appreciated by those skilled in the art that the iterativeprocess of removing instrumentation logic shown in FIGS. 10A-10D is butone possible method of observing hierarchical dependencies, if any,between instrumentation event instances while removing unnecessaryinstrumentation logic. For example, in alternative embodiments of thepresent invention, the observation of hierarchical dependencies ofinstrumentation event instances, and hence the preservation of logicelements needed to generate downstream instrumentation event instances,maybe implemented through the generation of a dependence graphindicating the dependence, if any, of downstream instrumentation eventinstances upon upstream instrumentation event instances.

As has been described, the present invention provides an improved dataprocessing system and method of processing. According to the method, asimulation model is received that includes a plurality of design entityinstances modeling a digital system and one or more instrumentationentity instances, separate from the plurality of design entityinstances, that generate instances of instrumentation events for testingpurposes during simulation. In response to receiving an exclusion listidentifying at least one instance of one or more instrumentation eventsto be removed from the simulation model, the at least one instance ofthe one or more instrumentation events and associated logic elements areremoved from the one or more instrumentation entity instances of thesimulation model prior to simulation. In this manner, a more compactsimulation model is obtained.

While the invention has been particularly shown as described withreference to a preferred embodiment, it will be understood by thoseskilled in the art that various changes in form and detail may be madetherein without departing from the spirit and scope of the invention.For example, although aspects of the present invention have beendescribed with respect to a computer system executing program code thatdirects the functions of the present invention, it should be understoodthat present invention may alternatively be implemented as a programproduct for use with a data processing system. Program code defining thefunctions of the present invention can be delivered to a data processingsystem via a variety of computer-usable or signal-bearing media, whichinclude, without limitation, non-rewritable storage media (e.g.,CD-ROM), rewritable storage media (e.g., a floppy diskette or hard diskdrive), and communication media, such as digital and analog networks. Itshould be understood, therefore, that such signal-bearing orcomputer-usable media, when carrying or encoding computer readableinstructions that direct the functions of the present invention,represent alternative embodiments of the present invention.

1. A method of processing in a data processing system, said methodcomprising: receiving a simulation model, said simulation modelincluding a plurality of design entity instances modeling a digitalsystem and one or more instrumentation entity instances, separate fromsaid plurality of design entity instances, that generate instances ofinstrumentation events for testing purposes during simulation; and inresponse to receiving an exclusion list identifying at least oneinstance of one or more instrumentation events to be removed from saidsimulation model, removing said at least one instance of said one ormore instrumentation events and associated logic elements from said oneor more instrumentation entity instances of said simulation model priorto simulation.
 2. The method of claim 1, wherein: said one or moreinstrumentation entity instances include a first instrumentation entityinstance having instances of first and second instrumentation events,said instance of said first instrumentation event having a first cone ofinfluence and said instance of said second instrumentation event havinga second cone of influence; and said removing comprises removing fromsaid first instrumentation entity instance at least one logic element insaid first cone of influence of said instance of said firstinstrumentation event and retaining logic elements in said second coneof influence of said instance of said second instrumentation event. 3.The method of claim 2, wherein: said first cone of influence of saidinstance of said first instrumentation event and said second cone ofinfluence of said instance of said second instrumentation event bothinclude a same logic element; and said removing comprises retaining saidsame logic element.
 4. The method of claim 1, and further comprisingmarking for removal logic elements of a first instrumentation entityinstance among said one or more instrumentation entity instances bytracing one or more signal paths backward from an instance of aninstrumentation event identified in said exclusion list to a boundarybetween said first instrumentation entity instance and a target designentity instance among said plurality of design entity instances.
 5. Themethod of claim 1, wherein: said one or more instrumentation entityinstances include a first instrumentation entity instance having aninstance of a first instrumentation event and a second instrumentationentity instance having an instance of a second instrumentation event,wherein said instance of said second instrumentation event depends uponsaid instance of said first instrumentation event; and said removingcomprises removing from said first instrumentation entity instance atleast one logic element in said first cone of influence of said instanceof said first instrumentation event only if said instance of said secondinstrumentation event is removed.
 6. The method of claim 5, and furthercomprising: in response to said instance of said first instrumentationevent being identified within said exclusion file, determining adependence of said instance of said second instrumentation event on saidinstance of said first instrumentation event.
 7. A program product,comprising: a computer-readable medium including program code thatcauses a data processing system to perform a process including:receiving a simulation model, said simulation model including aplurality of design entity instances modeling a digital system and oneor more instrumentation entity instances, separate from said pluralityof design entity instances, that generate instances of instrumentationevents for testing purposes during simulation; and in response toreceiving an exclusion list identifying at least one instance of one ormore instrumentation events to be removed from said simulation model,removing said at least one instance of said one or more instrumentationevents and associated logic elements from said one or moreinstrumentation entity instances of said simulation model prior tosimulation.
 8. The program product of claim 7, wherein: said one or moreinstrumentation entity instances include a first instrumentation entityinstance having instances of first and second instrumentation events,said instance of said first instrumentation event having a first cone ofinfluence and said instance of said second instrumentation event havinga second cone of influence; and said removing comprises removing fromsaid first instrumentation entity instance at least one logic element insaid first cone of influence of said instance of said firstinstrumentation event and retaining logic elements in said second coneof influence of said instance of said second instrumentation event. 9.The program product of claim 8, wherein: said first cone of influence ofsaid instance of said first instrumentation event and said second coneof influence of said instance of said second instrumentation event bothinclude a same logic element; and said removing comprises retaining saidsame logic element.
 10. The program product of claim 7, said processfurther comprising marking for removal logic elements of a firstinstrumentation entity instance among said one or more instrumentationentity instances by tracing one or more signal paths backward from aninstance of an instrumentation event identified in said exclusion listto a boundary between said first instrumentation entity instance and atarget design entity instance among said plurality of design entityinstances.
 11. The program product of claim 7, wherein: said one or moreinstrumentation entity instances include a first instrumentation entityinstance having an instance of a first instrumentation event and asecond instrumentation entity instance having an instance of a secondinstrumentation event, wherein said instance of said secondinstrumentation event depends upon said instance of said firstinstrumentation event; and said removing comprises removing from saidfirst instrumentation entity instance at least one logic element in saidfirst cone of influence of said instance of said first instrumentationevent only if said instance of said second instrumentation event isremoved.
 12. The program product of claim 11, said process furthercomprising: in response to said instance of said first instrumentationevent being identified within said exclusion file, determining adependence of said instance of said second instrumentation event on saidinstance of said first instrumentation event.
 13. A data processingsystem, comprising: a processor; and data storage coupled to saidprocessor and including a simulation model preprocessor that compacts asimulation model, said simulation model including a plurality of designentity instances modeling a digital system and one or moreinstrumentation entity instances, separate from said plurality of designentity instances, that generate instances of instrumentation events fortesting purposes during simulation; wherein said simulation modelpreprocessor, responsive to receiving an exclusion list identifying atleast one instance of one or more instrumentation events to be removedfrom said simulation model, removes said at least one instance of saidone or more instrumentation events and associated logic elements fromsaid one or more instrumentation entity instances of said simulationmodel prior to simulation.
 14. The data processing system of claim 13,wherein: said one or more instrumentation entity instances include afirst instrumentation entity instance having instances of first andsecond instrumentation events, said instance of said firstinstrumentation event having a first cone of influence and said instanceof said second instrumentation event having a second cone of influence;and said simulation model preprocessor removes from said firstinstrumentation entity instance at least one logic element in said firstcone of influence of said instance of said first instrumentation eventand retains logic elements in said second cone of influence of saidinstance of said second instrumentation event.
 15. The data processingsystem of claim 14, wherein: said first cone of influence of saidinstance of said first instrumentation event and said second cone ofinfluence of said instance of said second instrumentation event bothinclude a same logic element; and said simulation model preprocessorretains said same logic element in said simulation model.
 16. The dataprocessing system of claim 13, wherein said simulation modelpreprocessor marks for removal logic elements of a first instrumentationentity instance among said one or more instrumentation entity instancesby tracing one or more signal paths backward from an instance of aninstrumentation event identified in said exclusion list to a boundarybetween said first instrumentation entity instance and a target designentity instance among said plurality of design entity instances.
 17. Thedata processing system of claim 13, wherein: said one or moreinstrumentation entity instances include a first instrumentation entityinstance having an instance of a first instrumentation event and asecond instrumentation entity instance having an instance of a secondinstrumentation event, wherein said instance of said secondinstrumentation event depends upon said instance of said firstinstrumentation event; and said simulation model preprocessor removesfrom said first instrumentation entity instance at least one logicelement in said first cone of influence of said instance of said firstinstrumentation event only if said instance of said secondinstrumentation event is removed.
 18. The data processing system ofclaim 7, wherein said simulation model preprocessor, responsive to saidinstance of said first instrumentation event being identified withinsaid exclusion file, determines a dependence of said instance of saidsecond instrumentation event on said instance of said firstinstrumentation event.